home *** CD-ROM | disk | FTP | other *** search
/ Practical Algorithms for Image Analysis / Practical Algorithms for Image Analysis.iso / LIBIMAGE / GETOPT.C < prev    next >
C/C++ Source or Header  |  1999-09-11  |  4KB  |  142 lines
  1. /* 
  2.  * getopt.c
  3.  * 
  4.  * Practical Algorithms for Image Analysis
  5.  * 
  6.  * Copyright (c) 1999 SOS Software
  7.  */
  8.  
  9. /*
  10.  * GETOPT
  11.  *
  12.  * parse command line
  13.  *
  14.  * external variables:
  15.  *         char *optarg      a pointer that is initialized to NULL on
  16.  *                           entry to the function. If a command-line
  17.  *                           option has an argument, optarg points to
  18.  *                           the argument.
  19.  *
  20.  *         char *index       a pointer to the next character in the
  21.  *                           command line.
  22.  *
  23.  *         int optind        an index into the argument vector
  24.  *
  25.  *         int opterr        a flag that, if set to 0, turns off the
  26.  *                           display of a predefined error message
  27.  *                           on stderr. If nonzero, the message is
  28.  *                           displayed when an error occurs.
  29.  *
  30.  * in addition, the function uses the following variables in its 
  31.  * argument list:
  32.  *
  33.  *   Argument list:    int argc          the argument count from the
  34.  *                                       command line
  35.  *
  36.  *                     char *argv[]      the command-line vector
  37.  *                     char *optstring   a list of valid command-line
  38.  *                                       options
  39.  *
  40.  *   Return value:     int               the command-line option or EOF
  41.  *                                       on error or when parsing is
  42.  *                                       finished.
  43.  *
  44.  * (ref: J. Purdum, "C Programmer's Toolkit", chapt.5, listing 8)
  45.  *
  46.  */
  47. #include <io.h>
  48. #include <stdio.h>
  49. #include <stdlib.h>
  50. #include <fcntl.h>
  51. #include <sys/types.h>
  52. #include <sys/stat.h>
  53. #include <string.h>
  54. #include "getopt.h"
  55.  
  56. char *optarg;
  57. static char *index = NULL;
  58. int optind, opterr;
  59.  
  60. static void
  61. get_next_index (void)
  62. {
  63.   ++optind;
  64.   index = NULL;
  65. }
  66.  
  67.  
  68. int
  69. getopt (int argc, char *argv[], char *optstring)
  70. {
  71.   int fd, i;
  72.   char *ptr = NULL;
  73.  
  74.   optarg = NULL;
  75.   if (!optind) {                /* If not set to 1, set it to 1  */
  76.     index = (char *) NULL;
  77.     optind++;
  78.   }
  79.  
  80.   fd = fileno (stderr);
  81.   while (argv[optind]) {        /* Used for the write() function */
  82.     if (!index) {               /* If no index string yet   */
  83.       index = argv[optind];
  84.       if (!index || *index != '-') {  /*no index and  */
  85.         index = NULL;           /* no dash: done */
  86.         return (EOF);
  87.       }
  88.       if (*(++index) == '-') {  /* Double dash? */
  89.         get_next_index ();      /* Don't parse any more */
  90.         return EOF;
  91.       }
  92.       if (!*(index))            /* Ready for next iteration */
  93.         get_next_index ();
  94.  
  95.       continue;
  96.     }
  97.  
  98.     i = (int) *index++;         /* Look at next character */
  99.     if (i != ':') {             /* No command-line argument */
  100.       ptr = strchr (optstring, i);  /* Is i in options list? */
  101.       if (ptr && *(ptr + 1) == ':') {  /* Yes, plus argument  */
  102.         if (*index)             /* If non-NULL index...  */
  103.           optarg = index;       /* set optarg to pt to it */
  104.         else                    /* else get the next argv */
  105.           optarg = argv[++optind];
  106.  
  107.         get_next_index ();
  108.  
  109.         if (!optarg) {          /* Colon but no argument */
  110.           i = EOF;
  111.           if (opterr) {
  112.             write (fd, argv[0], strlen (argv[0]));
  113.             write (fd, ": option requires argument ", 27);
  114.             write (fd, &i, sizeof (char));
  115.             write (fd, "\r\n", 2);
  116.             exit (1);
  117.           }
  118.         }
  119.         return (i);             /* Must be an error */
  120.       }
  121.     }
  122.  
  123.     if (!(*index))              /* If a null character */
  124.       get_next_index ();
  125.  
  126.     if (ptr)                    /* Return the command option */
  127.       return (i);
  128.  
  129.     else {
  130.       if (opterr) {             /* Not in the list */
  131.         write (fd, argv[0], strlen (argv[0]));
  132.         write (fd, ": illegal option ", 17);
  133.         write (fd, &i, sizeof (char));
  134.         write (fd, "\r\n", 2);
  135.         exit (1);
  136.       }
  137.       return ('?');
  138.     }
  139.   }
  140.   return EOF;                   /* None left */
  141. }
  142.